

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
    <style>
    /* base */
    html,
    body,
    .container {
      width: 100%;
      height: 100%;
    }

    a,
    a:link,
    a:visited {
      text-decoration: none;
      color: inherit;
    }

    ul {
      list-style: none;
    }

    *,
    ::before,
    ::after {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }

    *:focus {
      outline: 0;
    }

    .container {
      display: flex;
      padding-top: 20px;
    }

    /* Nav */
    .container .doc-nav {
      position: fixed;
      height: 100%;
      margin: 0 30px 0 40px;
      width: 280px;
    }

    .doc-nav .nav-header {
      display: flex;
      align-items: center;
      box-sizing: border-box;
      background-color: rgb(240, 241, 242);
      height: 40px;
      padding: 16px;
      font-size: 18px;
      font-weight: 500;
      color: rgb(62, 64, 66);
      cursor: pointer;
    }

    .doc-nav .nav-content {
      height: calc(100% - 40px);
      overflow-y: auto;
      color: rgb(32, 34, 36);
    }

    .doc-nav .nav-content .nav-list,
    .doc-nav .nav-content .nav-sub-list {
      line-height: 1.5rem;
    }

    .doc-nav .nav-content .nav-label {
      display: inline-block;
      position: relative;
      padding: 2px 0 2px 20px;
      margin-bottom: 4px;
    }

    .doc-nav .nav-content .nav-sub-label {
      position: relative;
      padding: 2px 0 2px 40px;
      font-size: 14px;
    }

    .doc-nav .nav-content .nav-sub-label:hover {
      text-decoration: underline;
    }

    .doc-nav .nav-content .nav-list .nav-label.group::before {
      border-bottom: 0.25rem solid transparent;
      border-left: 0.25rem solid #6e7072;
      border-right: 0;
      border-top: 0.25rem solid transparent;
      content: '';
      display: block;
      height: 0;
      left: 0.5rem;
      position: absolute;
      top: 0.625rem;
      transition: transform 0.1s linear;
      width: 0;
    }

    .doc-nav .nav-content .nav-list .nav-label.group.active::before {
      transform: rotate(90deg);
    }

    /* doc content */
    .container .doc-content {
      position: fixed;
      height: 100%;
      width: calc(100% - 80px - 40px - 30px - 240px);
      right: 0%;
      overflow-y: auto;
    }

    .doc-title {
      border-bottom: 1px solid #dcdee0;
      font-size: 22px;
      margin: 8px 0 0;
      padding-bottom: 16px;
    }

    .doc-content h3 {
      font-size: 24px;
      font-weight: 600;
      margin: 24px 0;
    }

    .doc-content h4 {
      font-size: 22px;
      font-weight: 500;
      margin: 30px 0 8px;
    }

    .doc-content h4 span {
      color: #007d9c;
    }

    .doc-content .doc-declare {
      background-color: #fafafa;
      border-radius: 5px;
      border: 1px solid #ccc;
      font-size: 14px;
      overflow-x: auto;
      padding: 10px;
      tab-size: 4;
      line-height: 20px;
    }

    .doc-content .doc-comment {
      font-size: 16px;
      margin: 16px 0;
      line-height: 24px;
      word-break: break-word;
    }
  </style>

</head>
<body>
  <div class="container">
    <div class="doc-nav">
      <a href="#Documentation" class="nav-header">Documentation</a>
      <nav class="nav-content">
        <ul class="nav-list">
          <li>
            <a href="#includes" class="nav-label">Includes</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#config.h" class="nav-sub-label">config.h</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_CONFIG_FILE" class="nav-sub-label">MBEDTLS_CONFIG_FILE</a>
              </li>
      

              <li>
                <a href="#ecp.h" class="nav-sub-label">ecp.h</a>
              </li>
      

              <li>
                <a href="#md.h" class="nav-sub-label">md.h</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#macros" class="nav-label">Macros</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#MBEDTLS_ECDSA_H" class="nav-sub-label">MBEDTLS_ECDSA_H</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_ECDSA_MAX_LEN" class="nav-sub-label">MBEDTLS_ECDSA_MAX_LEN</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_DEPRECATED" class="nav-sub-label">MBEDTLS_DEPRECATED</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_DEPRECATED" class="nav-sub-label">MBEDTLS_DEPRECATED</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#functions" class="nav-label">Functions</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#mbedtls_ecdsa_sign" class="nav-sub-label">mbedtls_ecdsa_sign</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_sign_det" class="nav-sub-label">mbedtls_ecdsa_sign_det</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_verify" class="nav-sub-label">mbedtls_ecdsa_verify</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_write_signature" class="nav-sub-label">mbedtls_ecdsa_write_signature</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_write_signature_restartable" class="nav-sub-label">mbedtls_ecdsa_write_signature_restartable</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_write_signature_det" class="nav-sub-label">mbedtls_ecdsa_write_signature_det</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_read_signature" class="nav-sub-label">mbedtls_ecdsa_read_signature</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_read_signature_restartable" class="nav-sub-label">mbedtls_ecdsa_read_signature_restartable</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_genkey" class="nav-sub-label">mbedtls_ecdsa_genkey</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_from_keypair" class="nav-sub-label">mbedtls_ecdsa_from_keypair</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_init" class="nav-sub-label">mbedtls_ecdsa_init</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_free" class="nav-sub-label">mbedtls_ecdsa_free</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_init" class="nav-sub-label">mbedtls_ecdsa_restart_init</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_free" class="nav-sub-label">mbedtls_ecdsa_restart_free</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#vars" class="nav-label">Vars</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#consts" class="nav-label">Consts</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#types" class="nav-label">Types</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#typedefs" class="nav-label">Typedefs</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#mbedtls_ecdsa_context" class="nav-sub-label">mbedtls_ecdsa_context</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_ver_ctx" class="nav-sub-label">mbedtls_ecdsa_restart_ver_ctx</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_sig_ctx" class="nav-sub-label">mbedtls_ecdsa_restart_sig_ctx</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_det_ctx" class="nav-sub-label">mbedtls_ecdsa_restart_det_ctx</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_ctx;
" class="nav-sub-label">mbedtls_ecdsa_restart_ctx;
</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdsa_restart_ctx" class="nav-sub-label">mbedtls_ecdsa_restart_ctx</a>
              </li>
      
            </ul>
            
          </li>
        </ul>
      </nav>
    </div>
    <div class="doc-content">
      <h2 id="Documentation" class="doc-title">Documentation</h2>
      <h3 id="includes">Includes</h3>
      

      <h4 id="config.h"><span>config.h</span></h4>
      <pre class="doc-declare"><code>#include "config.h"
</code></pre>
      <pre class="doc-comment">#include "config.h"
</pre>

      <h4 id="MBEDTLS_CONFIG_FILE"><span>MBEDTLS_CONFIG_FILE</span></h4>
      <pre class="doc-declare"><code>#include MBEDTLS_CONFIG_FILE
</code></pre>
      <pre class="doc-comment">#include MBEDTLS_CONFIG_FILE
</pre>

      <h4 id="ecp.h"><span>ecp.h</span></h4>
      <pre class="doc-declare"><code>#include "ecp.h"
</code></pre>
      <pre class="doc-comment">#include "ecp.h"
</pre>

      <h4 id="md.h"><span>md.h</span></h4>
      <pre class="doc-declare"><code>#include "md.h"
</code></pre>
      <pre class="doc-comment">#include "md.h"
</pre>
      <h3 id="macros">Macros</h3>
      

      <h4 id="MBEDTLS_ECDSA_H">Marco <span>MBEDTLS_ECDSA_H</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ECDSA_H
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="MBEDTLS_ECDSA_MAX_LEN">Marco <span>MBEDTLS_ECDSA_MAX_LEN</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ECDSA_MAX_LEN ( 3 + 2 * ( 3 + MBEDTLS_ECP_MAX_BYTES ) )
</code></pre>
      <pre class="doc-comment">/** The maximal size of an ECDSA signature in Bytes. */</pre>

      <h4 id="MBEDTLS_DEPRECATED">Marco <span>MBEDTLS_DEPRECATED</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_DEPRECATED   __attribute__((deprecated))
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="MBEDTLS_DEPRECATED">Marco <span>MBEDTLS_DEPRECATED</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_DEPRECATED
</code></pre>
      <pre class="doc-comment"></pre>
      <h3 id="functions">Functions</h3>
      

      <h4 id="mbedtls_ecdsa_sign">Func <span>mbedtls_ecdsa_sign</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
               const mbedtls_mpi *d, const unsigned char *buf, size_t blen,
               int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes the ECDSA signature of a
 *                  previously-hashed message.
 *
 * \note            The deterministic version implemented in
 *                  mbedtls_ecdsa_sign_det() is usually preferred.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated
 *                  as defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.3, step 5.
 *
 * \see             ecp.h
 *
 * \param grp       The context for the elliptic curve to use.
 *                  This must be initialized and have group parameters
 *                  set, for example through mbedtls_ecp_group_load().
 * \param r         The MPI context in which to store the first part
 *                  the signature. This must be initialized.
 * \param s         The MPI context in which to store the second part
 *                  the signature. This must be initialized.
 * \param d         The private signing key. This must be initialized.
 * \param buf       The content to be signed. This is usually the hash of
 *                  the original data to be signed. This must be a readable
 *                  buffer of length \p blen Bytes. It may be \c NULL if
 *                  \p blen is zero.
 * \param blen      The length of \p buf in Bytes.
 * \param f_rng     The RNG function. This must not be \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL if \p f_rng doesn't need a context parameter.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX
 *                  or \c MBEDTLS_MPI_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_sign_det">Func <span>mbedtls_ecdsa_sign_det</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_sign_det( mbedtls_ecp_group *grp, mbedtls_mpi *r,
                           mbedtls_mpi *s, const mbedtls_mpi *d,
                           const unsigned char *buf, size_t blen,
                           mbedtls_md_type_t md_alg );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes the ECDSA signature of a
 *                  previously-hashed message, deterministic version.
 *
 *                  For more information, see <em>RFC-6979: Deterministic
 *                  Usage of the Digital Signature Algorithm (DSA) and Elliptic
 *                  Curve Digital Signature Algorithm (ECDSA)</em>.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated as
 *                  defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.3, step 5.
 *
 * \see             ecp.h
 *
 * \param grp       The context for the elliptic curve to use.
 *                  This must be initialized and have group parameters
 *                  set, for example through mbedtls_ecp_group_load().
 * \param r         The MPI context in which to store the first part
 *                  the signature. This must be initialized.
 * \param s         The MPI context in which to store the second part
 *                  the signature. This must be initialized.
 * \param d         The private signing key. This must be initialized
 *                  and setup, for example through mbedtls_ecp_gen_privkey().
 * \param buf       The hashed content to be signed. This must be a readable
 *                  buffer of length \p blen Bytes. It may be \c NULL if
 *                  \p blen is zero.
 * \param blen      The length of \p buf in Bytes.
 * \param md_alg    The hash algorithm used to hash the original data.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX or \c MBEDTLS_MPI_XXX
 *                  error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_verify">Func <span>mbedtls_ecdsa_verify</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp,
                         const unsigned char *buf, size_t blen,
                         const mbedtls_ecp_point *Q, const mbedtls_mpi *r,
                         const mbedtls_mpi *s);</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function verifies the ECDSA signature of a
 *                  previously-hashed message.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated as
 *                  defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.4, step 3.
 *
 * \see             ecp.h
 *
 * \param grp       The ECP group to use.
 *                  This must be initialized and have group parameters
 *                  set, for example through mbedtls_ecp_group_load().
 * \param buf       The hashed content that was signed. This must be a readable
 *                  buffer of length \p blen Bytes. It may be \c NULL if
 *                  \p blen is zero.
 * \param blen      The length of \p buf in Bytes.
 * \param Q         The public key to use for verification. This must be
 *                  initialized and setup.
 * \param r         The first integer of the signature.
 *                  This must be initialized.
 * \param s         The second integer of the signature.
 *                  This must be initialized.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if the signature
 *                  is invalid.
 * \return          An \c MBEDTLS_ERR_ECP_XXX or \c MBEDTLS_MPI_XXX
 *                  error code on failure for any other reason.
 */</pre>

      <h4 id="mbedtls_ecdsa_write_signature">Func <span>mbedtls_ecdsa_write_signature</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_write_signature( mbedtls_ecdsa_context *ctx,
                                  mbedtls_md_type_t md_alg,
                          const unsigned char *hash, size_t hlen,
                          unsigned char *sig, size_t *slen,
                          int (*f_rng)(void *, unsigned char *, size_t),
                          void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes the ECDSA signature and writes it
 *                  to a buffer, serialized as defined in <em>RFC-4492:
 *                  Elliptic Curve Cryptography (ECC) Cipher Suites for
 *                  Transport Layer Security (TLS)</em>.
 *
 * \warning         It is not thread-safe to use the same context in
 *                  multiple threads.
 *
 * \note            The deterministic version is used if
 *                  #MBEDTLS_ECDSA_DETERMINISTIC is defined. For more
 *                  information, see <em>RFC-6979: Deterministic Usage
 *                  of the Digital Signature Algorithm (DSA) and Elliptic
 *                  Curve Digital Signature Algorithm (ECDSA)</em>.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated as
 *                  defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.3, step 5.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDSA context to use. This must be initialized
 *                  and have a group and private key bound to it, for example
 *                  via mbedtls_ecdsa_genkey() or mbedtls_ecdsa_from_keypair().
 * \param md_alg    The message digest that was used to hash the message.
 * \param hash      The message hash to be signed. This must be a readable
 *                  buffer of length \p blen Bytes.
 * \param hlen      The length of the hash \p hash in Bytes.
 * \param sig       The buffer to which to write the signature. This must be a
 *                  writable buffer of length at least twice as large as the
 *                  size of the curve used, plus 9. For example, 73 Bytes if
 *                  a 256-bit curve is used. A buffer length of
 *                  #MBEDTLS_ECDSA_MAX_LEN is always safe.
 * \param slen      The address at which to store the actual length of
 *                  the signature written. Must not be \c NULL.
 * \param f_rng     The RNG function. This must not be \c NULL if
 *                  #MBEDTLS_ECDSA_DETERMINISTIC is unset. Otherwise,
 *                  it is unused and may be set to \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL if \p f_rng is \c NULL or doesn't use a context.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX, \c MBEDTLS_ERR_MPI_XXX or
 *                  \c MBEDTLS_ERR_ASN1_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_write_signature_restartable">Func <span>mbedtls_ecdsa_write_signature_restartable</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_write_signature_restartable( mbedtls_ecdsa_context *ctx,
                          mbedtls_md_type_t md_alg,
                          const unsigned char *hash, size_t hlen,
                          unsigned char *sig, size_t *slen,
                          int (*f_rng)(void *, unsigned char *, size_t),
                          void *p_rng,
                          mbedtls_ecdsa_restart_ctx *rs_ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes the ECDSA signature and writes it
 *                  to a buffer, in a restartable way.
 *
 * \see             \c mbedtls_ecdsa_write_signature()
 *
 * \note            This function is like \c mbedtls_ecdsa_write_signature()
 *                  but it can return early and restart according to the limit
 *                  set with \c mbedtls_ecp_set_max_ops() to reduce blocking.
 *
 * \param ctx       The ECDSA context to use. This must be initialized
 *                  and have a group and private key bound to it, for example
 *                  via mbedtls_ecdsa_genkey() or mbedtls_ecdsa_from_keypair().
 * \param md_alg    The message digest that was used to hash the message.
 * \param hash      The message hash to be signed. This must be a readable
 *                  buffer of length \p blen Bytes.
 * \param hlen      The length of the hash \p hash in Bytes.
 * \param sig       The buffer to which to write the signature. This must be a
 *                  writable buffer of length at least twice as large as the
 *                  size of the curve used, plus 9. For example, 73 Bytes if
 *                  a 256-bit curve is used. A buffer length of
 *                  #MBEDTLS_ECDSA_MAX_LEN is always safe.
 * \param slen      The address at which to store the actual length of
 *                  the signature written. Must not be \c NULL.
 * \param f_rng     The RNG function. This must not be \c NULL if
 *                  #MBEDTLS_ECDSA_DETERMINISTIC is unset. Otherwise,
 *                  it is unused and may be set to \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL if \p f_rng is \c NULL or doesn't use a context.
 * \param rs_ctx    The restart context to use. This may be \c NULL to disable
 *                  restarting. If it is not \c NULL, it must point to an
 *                  initialized restart context.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
 *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
 * \return          Another \c MBEDTLS_ERR_ECP_XXX, \c MBEDTLS_ERR_MPI_XXX or
 *                  \c MBEDTLS_ERR_ASN1_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_write_signature_det">Func <span>mbedtls_ecdsa_write_signature_det</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_write_signature_det( mbedtls_ecdsa_context *ctx,
                              const unsigned char *hash, size_t hlen,
                              unsigned char *sig, size_t *slen,
                              mbedtls_md_type_t md_alg ) MBEDTLS_DEPRECATED;</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes an ECDSA signature and writes
 *                  it to a buffer, serialized as defined in <em>RFC-4492:
 *                  Elliptic Curve Cryptography (ECC) Cipher Suites for
 *                  Transport Layer Security (TLS)</em>.
 *
 *                  The deterministic version is defined in <em>RFC-6979:
 *                  Deterministic Usage of the Digital Signature Algorithm (DSA)
 *                  and Elliptic Curve Digital Signature Algorithm (ECDSA)</em>.
 *
 * \warning         It is not thread-safe to use the same context in
 *                  multiple threads.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated as
 *                  defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.3, step 5.
 *
 * \see             ecp.h
 *
 * \deprecated      Superseded by mbedtls_ecdsa_write_signature() in
 *                  Mbed TLS version 2.0 and later.
 *
 * \param ctx       The ECDSA context to use. This must be initialized
 *                  and have a group and private key bound to it, for example
 *                  via mbedtls_ecdsa_genkey() or mbedtls_ecdsa_from_keypair().
 * \param hash      The message hash to be signed. This must be a readable
 *                  buffer of length \p blen Bytes.
 * \param hlen      The length of the hash \p hash in Bytes.
 * \param sig       The buffer to which to write the signature. This must be a
 *                  writable buffer of length at least twice as large as the
 *                  size of the curve used, plus 9. For example, 73 Bytes if
 *                  a 256-bit curve is used. A buffer length of
 *                  #MBEDTLS_ECDSA_MAX_LEN is always safe.
 * \param slen      The address at which to store the actual length of
 *                  the signature written. Must not be \c NULL.
 * \param md_alg    The message digest that was used to hash the message.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX, \c MBEDTLS_ERR_MPI_XXX or
 *                  \c MBEDTLS_ERR_ASN1_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_read_signature">Func <span>mbedtls_ecdsa_read_signature</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_read_signature( mbedtls_ecdsa_context *ctx,
                         const unsigned char *hash, size_t hlen,
                         const unsigned char *sig, size_t slen );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function reads and verifies an ECDSA signature.
 *
 * \note            If the bitlength of the message hash is larger than the
 *                  bitlength of the group order, then the hash is truncated as
 *                  defined in <em>Standards for Efficient Cryptography Group
 *                  (SECG): SEC1 Elliptic Curve Cryptography</em>, section
 *                  4.1.4, step 3.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDSA context to use. This must be initialized
 *                  and have a group and public key bound to it.
 * \param hash      The message hash that was signed. This must be a readable
 *                  buffer of length \p size Bytes.
 * \param hlen      The size of the hash \p hash.
 * \param sig       The signature to read and verify. This must be a readable
 *                  buffer of length \p slen Bytes.
 * \param slen      The size of \p sig in Bytes.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if signature is invalid.
 * \return          #MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH if there is a valid
 *                  signature in \p sig, but its length is less than \p siglen.
 * \return          An \c MBEDTLS_ERR_ECP_XXX or \c MBEDTLS_ERR_MPI_XXX
 *                  error code on failure for any other reason.
 */</pre>

      <h4 id="mbedtls_ecdsa_read_signature_restartable">Func <span>mbedtls_ecdsa_read_signature_restartable</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_read_signature_restartable( mbedtls_ecdsa_context *ctx,
                         const unsigned char *hash, size_t hlen,
                         const unsigned char *sig, size_t slen,
                         mbedtls_ecdsa_restart_ctx *rs_ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function reads and verifies an ECDSA signature,
 *                  in a restartable way.
 *
 * \see             \c mbedtls_ecdsa_read_signature()
 *
 * \note            This function is like \c mbedtls_ecdsa_read_signature()
 *                  but it can return early and restart according to the limit
 *                  set with \c mbedtls_ecp_set_max_ops() to reduce blocking.
 *
 * \param ctx       The ECDSA context to use. This must be initialized
 *                  and have a group and public key bound to it.
 * \param hash      The message hash that was signed. This must be a readable
 *                  buffer of length \p size Bytes.
 * \param hlen      The size of the hash \p hash.
 * \param sig       The signature to read and verify. This must be a readable
 *                  buffer of length \p slen Bytes.
 * \param slen      The size of \p sig in Bytes.
 * \param rs_ctx    The restart context to use. This may be \c NULL to disable
 *                  restarting. If it is not \c NULL, it must point to an
 *                  initialized restart context.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if signature is invalid.
 * \return          #MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH if there is a valid
 *                  signature in \p sig, but its length is less than \p siglen.
 * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
 *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
 * \return          Another \c MBEDTLS_ERR_ECP_XXX or \c MBEDTLS_ERR_MPI_XXX
 *                  error code on failure for any other reason.
 */</pre>

      <h4 id="mbedtls_ecdsa_genkey">Func <span>mbedtls_ecdsa_genkey</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_genkey( mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id gid,
                 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief          This function generates an ECDSA keypair on the given curve.
 *
 * \see            ecp.h
 *
 * \param ctx      The ECDSA context to store the keypair in.
 *                 This must be initialized.
 * \param gid      The elliptic curve to use. One of the various
 *                 \c MBEDTLS_ECP_DP_XXX macros depending on configuration.
 * \param f_rng    The RNG function to use. This must not be \c NULL.
 * \param p_rng    The RNG context to be passed to \p f_rng. This may be
 *                 \c NULL if \p f_rng doesn't need a context argument.
 *
 * \return         \c 0 on success.
 * \return         An \c MBEDTLS_ERR_ECP_XXX code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_from_keypair">Func <span>mbedtls_ecdsa_from_keypair</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdsa_from_keypair( mbedtls_ecdsa_context *ctx,
                               const mbedtls_ecp_keypair *key );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function sets up an ECDSA context from an EC key pair.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDSA context to setup. This must be initialized.
 * \param key       The EC key to use. This must be initialized and hold
 *                  a private-public key pair or a public key. In the former
 *                  case, the ECDSA context may be used for signature creation
 *                  and verification after this call. In the latter case, it
 *                  may be used for signature verification.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX code on failure.
 */</pre>

      <h4 id="mbedtls_ecdsa_init">Func <span>mbedtls_ecdsa_init</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdsa_init( mbedtls_ecdsa_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function initializes an ECDSA context.
 *
 * \param ctx       The ECDSA context to initialize.
 *                  This must not be \c NULL.
 */</pre>

      <h4 id="mbedtls_ecdsa_free">Func <span>mbedtls_ecdsa_free</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdsa_free( mbedtls_ecdsa_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function frees an ECDSA context.
 *
 * \param ctx       The ECDSA context to free. This may be \c NULL,
 *                  in which case this function does nothing. If it
 *                  is not \c NULL, it must be initialized.
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_init">Func <span>mbedtls_ecdsa_restart_init</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdsa_restart_init( mbedtls_ecdsa_restart_ctx *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           Initialize a restart context.
 *
 * \param ctx       The restart context to initialize.
 *                  This must not be \c NULL.
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_free">Func <span>mbedtls_ecdsa_restart_free</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdsa_restart_free( mbedtls_ecdsa_restart_ctx *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           Free the components of a restart context.
 *
 * \param ctx       The restart context to free. This may be \c NULL,
 *                  in which case this function does nothing. If it
 *                  is not \c NULL, it must be initialized.
 */</pre>
      <h3 id="vars">Vars</h3>
      
      <h3 id="consts">Consts</h3>
      
      <h3 id="types">Types</h3>
      
      <h3 id="typedefs">Typedefs</h3>
      

      <h4 id="mbedtls_ecdsa_context">Typedef <span>mbedtls_ecdsa_context</span></h4>
      <pre class="doc-declare"><code>typedef mbedtls_ecp_keypair mbedtls_ecdsa_context;
</code></pre>
      <pre class="doc-comment">/**
 * \brief           The ECDSA context structure.
 *
 * \warning         Performing multiple operations concurrently on the same
 *                  ECDSA context is not supported; objects of this type
 *                  should not be shared between multiple threads.
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_ver_ctx">Typedef <span>mbedtls_ecdsa_restart_ver_ctx</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_ecdsa_restart_ver mbedtls_ecdsa_restart_ver_ctx;
</code></pre>
      <pre class="doc-comment">/**
 * \brief           Internal restart context for ecdsa_verify()
 *
 * \note            Opaque struct, defined in ecdsa.c
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_sig_ctx">Typedef <span>mbedtls_ecdsa_restart_sig_ctx</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_ecdsa_restart_sig mbedtls_ecdsa_restart_sig_ctx;
</code></pre>
      <pre class="doc-comment">/**
 * \brief           Internal restart context for ecdsa_sign()
 *
 * \note            Opaque struct, defined in ecdsa.c
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_det_ctx">Typedef <span>mbedtls_ecdsa_restart_det_ctx</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_ecdsa_restart_det mbedtls_ecdsa_restart_det_ctx;</code></pre>
      <pre class="doc-comment">/**
 * \brief           Internal restart context for ecdsa_sign_det()
 *
 * \note            Opaque struct, defined in ecdsa.c
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_ctx;
">Typedef <span>mbedtls_ecdsa_restart_ctx;
</span></h4>
      <pre class="doc-declare"><code>typedef struct
{
   mbedtls_ecp_restart_ctx ecp;       /*!<  base context for ECP restart and
                                              shared administrative info    */
   mbedtls_ecdsa_restart_ver_ctx *ver; /*!<  ecdsa_verify() sub-context    */
   mbedtls_ecdsa_restart_sig_ctx *sig; /*!<  ecdsa_sign() sub-context      */
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
   mbedtls_ecdsa_restart_det_ctx *det; /*!<  ecdsa_sign_det() sub-context  */
#endif
} mbedtls_ecdsa_restart_ctx;
</code></pre>
      <pre class="doc-comment">/**
 * \brief           General context for resuming ECDSA operations
 */</pre>

      <h4 id="mbedtls_ecdsa_restart_ctx">Typedef <span>mbedtls_ecdsa_restart_ctx</span></h4>
      <pre class="doc-declare"><code>typedef void mbedtls_ecdsa_restart_ctx;
</code></pre>
      <pre class="doc-comment">/* Now we can declare functions that take a pointer to that */</pre>
    </div>
  </body>
</html>
            